home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / glibmm-2.4 / proc / pm / FunctionBase.pm < prev    next >
Text File  |  2006-04-20  |  4KB  |  211 lines
  1. package FunctionBase;
  2.  
  3. use strict;
  4. use warnings;
  5. use Util;
  6.  
  7. BEGIN {
  8.      use Exporter   ();
  9.      our ($VERSION, @ISA, @EXPORT, @EXPORT_OK, %EXPORT_TAGS);
  10.  
  11.      # set the version for version checking
  12.      $VERSION     = 1.00;
  13.      @ISA         = qw(Exporter);
  14.      @EXPORT      = qw(&func1 &func2 &func4);
  15.      %EXPORT_TAGS = ( );
  16.      # your exported package globals go here,
  17.      # as well as any optionally exported functions
  18.      @EXPORT_OK   = qw($Var1 %Hashit &func3);
  19.      }
  20. our @EXPORT_OK;
  21.  
  22. ##################################################
  23. ### FunctionBase
  24. # Contains data and methods used by both Function (C++ declarations) and GtkDefs::Function (C defs descriptions)
  25. # Note that GtkDefs::Signal inherits from GtkDefs::Function so it get these methods too.
  26. #
  27. #  class Function : FunctionBase
  28. #    {
  29. #       string array param_types;
  30. #       string array param_names;
  31. #       string array param_documentation;
  32. #       string return_documention;
  33. #    }
  34.  
  35.  
  36. # $string args_types_only($)
  37. # comma-delimited argument types.
  38. sub args_types_only($)
  39. {
  40.   my ($self) = @_;
  41.  
  42.   my $param_types = $$self{param_types};
  43.   return join(", ", @$param_types);
  44. }
  45.  
  46. # $string args_names_only($)
  47. sub args_names_only($)
  48. {
  49.   my ($self) = @_;
  50.  
  51.   my $param_names = $$self{param_names};
  52.   return join(", ", @$param_names);
  53. }
  54.  
  55. # $string args_types_and_names($)
  56. sub args_types_and_names($)
  57. {
  58.   my ($self) = @_;
  59.  
  60.   my $i;
  61.  
  62.   my $param_names = $$self{param_names};
  63.   my $param_types = $$self{param_types};
  64.   my @out;
  65.  
  66.   for ($i = 0; $i < $#$param_types + 1; $i++)
  67.   {
  68.     my $str = sprintf("%s %s", $$param_types[$i], $$param_names[$i]);
  69.     push(@out, $str);
  70.   }
  71.  
  72.   return join(", ", @out);
  73. }
  74.  
  75. # $string args_names_only_without_object($)
  76. sub args_names_only_without_object2($)
  77. {
  78.   my ($self) = @_;
  79.  
  80.   my $param_names = $$self{param_names};
  81.  
  82.   my $result = "";
  83.   my $bInclude = 0; #Ignore the first (object) arg.
  84.   foreach (@{$param_names})
  85.   {
  86.     # Add comma if there was an arg before this one:
  87.     if( $result ne "")
  88.     {
  89.       $result .= ", ";
  90.     }
  91.  
  92.     # Append this arg if it's not the first one:
  93.     if($bInclude)
  94.     {
  95.       $result .= $_;
  96.     }
  97.  
  98.     $bInclude = 1;
  99.   }
  100.  
  101.   return $result;
  102. }
  103.  
  104. # $string args_types_and_names_without_object($)
  105. sub args_types_and_names_without_object($)
  106. {
  107.   my ($self) = @_;
  108.  
  109.   my $param_names = $$self{param_names};
  110.   my $param_types = $$self{param_types};
  111.   my $i = 0;
  112.   my @out;
  113.  
  114.   for ($i = 1; $i < $#$param_types + 1; $i++) #Ignore the first arg.
  115.   {
  116.     my $str = sprintf("%s %s", $$param_types[$i], $$param_names[$i]);
  117.     push(@out, $str);
  118.   }
  119.  
  120.   return join(", ", @out);
  121. }
  122.  
  123. # $string args_names_only_without_object($)
  124. sub args_names_only_without_object($)
  125. {
  126.   my ($self) = @_;
  127.  
  128.   my $param_names = $$self{param_names};
  129.  
  130.   my $result = "";
  131.   my $bInclude = 0; #Ignore the first (object) arg.
  132.   foreach (@{$param_names})
  133.   {
  134.     # Add comma if there was an arg before this one:
  135.     if( $result ne "")
  136.     {
  137.       $result .= ", ";
  138.     }
  139.  
  140.     # Append this arg if it's not the first one:
  141.     if($bInclude)
  142.     {
  143.       $result .= $_;
  144.     }
  145.  
  146.     $bInclude = 1;
  147.   }
  148.  
  149.   return $result;
  150. }
  151.  
  152. sub dump($)
  153. {
  154.   my ($self) = @_;
  155.  
  156.   my $param_types = $$self{param_types};
  157.   my $param_names = $$self{param_names};
  158.  
  159.   print "<function>\n";
  160.   foreach (keys %$self)
  161.   {
  162.     print "  <$_ value=\"$$self{$_}\"/>\n" if (!ref $$self{$_} && $$self{$_} ne "");
  163.   }
  164.  
  165.   if (scalar(@$param_types)>0)
  166.   {
  167.     print "  <parameters>\n";
  168.  
  169.     for (my $i = 0; $i < scalar(@$param_types); $i++)
  170.     {
  171.       print "    \"$$param_types[$i]\" \"$$param_names[$i]\" \n";
  172.     }
  173.  
  174.     print "  </parameters>\n";
  175.   }
  176.  
  177.   print "</function>\n\n";
  178. }
  179.  
  180. sub args_types_and_names_with_default_values($)
  181. {
  182.   my ($self) = @_;
  183.  
  184.   my $i;
  185.  
  186.   my $param_names = $$self{param_names};
  187.   my $param_types = $$self{param_types};
  188.   my $param_default_values = $$self{param_default_values};
  189.   my @out;
  190.   
  191.   for ($i = 0; $i < $#$param_types + 1; $i++)
  192.   {
  193.     my $str = sprintf("%s %s", $$param_types[$i], $$param_names[$i]);
  194.  
  195.     if(defined($$param_default_values[$i]))
  196.     {
  197.       if($$param_default_values[$i] ne "")
  198.       {
  199.         $str .= " = " . $$param_default_values[$i];
  200.       }
  201.     }
  202.  
  203.     push(@out, $str);
  204.   }
  205.  
  206.   return join(", ", @out);
  207. }
  208.  
  209. 1; # indicate proper module load.
  210.  
  211.